package com.chenjie.future.controller;

import org.springframework.aop.support.AopUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.*;

/**
 * CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步回调、流式处理、
 * 多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。
 */
@RestController
@RequestMapping("completableFuture")
public class CompletableFutureTest {


    /**一：创建异步任务*/


    /**
     * 1、Future.submit
     * <p>
     * 通常的线程池接口类ExecutorService，其中execute方法的返回值是void，即无法获取异步任务的执行状态，3个重载的submit方法的返回值是Future，可以据此获取任务执行的状态和结果，示例如下
     * <p>
     * 执行结果如下
     * main thread start,time->1693553063072
     * Thread[pool-1-thread-1,5,main] start,time->1693553063072
     * Thread[pool-1-thread-1,5,main] exit,time->1693553065085
     * run result->1.2
     * main thread exit,time->1693553065085
     * <p>
     * <p>
     * 子线程是异步执行的，主线程休眠等待子线程执行完成，子线程执行完成后唤醒主线程，主线程获取任务执行结果后退出。
     * <p>
     * 很多博客说使用不带等待时间限制的get方法时，如果子线程执行异常了会导致主线程长期阻塞，这其实是错误的，子线程执行异常时其异常会被捕获，
     * 然后修改任务的状态为异常结束并唤醒等待的主线程，get方法判断任务状态发生变更，就终止等待了，并抛出异常。将上述用例中if(false)改成if(true) ，执行结果如下：
     * <p>
     * main thread start,time->1693555181005
     * Thread[pool-1-thread-1,5,main] start,time->1693555181005
     * 2023-09-01 15:59:43.033 ERROR 21368 --- [nio-8005-exec-1] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.util.concurrent.ExecutionException: java.lang.RuntimeException: test] with root cause
     * <p>
     * java.lang.RuntimeException: test
     * at com.chenjie.future.controller.CompletableFutureTest.lambda$submit$0(CompletableFutureTest.java:51) ~[classes/:na]
     * at java.util.concurrent.FutureTask.run(FutureTask.java:266) ~[na:1.8.0_361]
     * at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) ~[na:1.8.0_361]
     * at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) ~[na:1.8.0_361]
     * at java.lang.Thread.run(Thread.java:750) [na:1.8.0_361]
     * <p>
     * get方法抛出异常导致主线程异常终止。
     */
    @RequestMapping("/submit")
    public void submit() throws ExecutionException, InterruptedException {
        // 创建异步执行任务:
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<Double> cf = executorService.submit(() -> {
            System.out.println(Thread.currentThread() + " start,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if (true) {
                throw new RuntimeException("test");
            } else {
                System.out.println(Thread.currentThread() + " exit,time->" + System.currentTimeMillis());
                return 1.2;
            }
        });
        System.out.println("main thread start,time->" + System.currentTimeMillis());
        //等待子任务执行完成,如果已完成则直接返回结果
        //如果执行任务异常，则get方法会把之前捕获的异常重新抛出
        System.out.println("run result->" + cf.get());
        System.out.println("main thread exit,time->" + System.currentTimeMillis());
/*        main thread start,time->1693553063072
        Thread[pool-1-thread-1,5,main] start,time->1693553063072
        Thread[pool-1-thread-1,5,main] exit,time->1693553065085
        run result->1.2
        main thread exit,time->1693553065085*/
    }


    /**
     * 2、supplyAsync / runAsync
     * <p>
     * supplyAsync表示创建带返回值的异步任务的，相当于ExecutorService submit(Callable<T> task) 方法，runAsync表示创建无返回值的异步任务，相当于
     * ExecutorService submit(Runnable task)方法，这两方法的效果跟submit是一样的，测试用例如下
     */
    @RequestMapping("/supplyAsync")
    public void supplyAsync() throws ExecutionException, InterruptedException {
        // 创建异步执行任务，有返回值
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread() + " start,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if (false) {
                throw new RuntimeException("test");
            } else {
                System.out.println(Thread.currentThread() + " exit,time->" + System.currentTimeMillis());
                return 1.2;
            }
        });
        System.out.println("main thread start,time->" + System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->" + cf.get());
        System.out.println("main thread exit,time->" + System.currentTimeMillis());
    }


    @RequestMapping("/supplyAsyncExecutor")
    public void supplyAsyncExecutor() throws ExecutionException, InterruptedException {
        ForkJoinPool pool = new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread() + " start,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if (false) {
                throw new RuntimeException("test");
            } else {
                System.out.println(Thread.currentThread() + " exit,time->" + System.currentTimeMillis());
                return 1.2;
            }
        }, pool);
        System.out.println("main thread start,time->" + System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->" + cf.get());
        System.out.println("main thread exit,time->" + System.currentTimeMillis());
    }

    /**
     * 这两方法各有一个重载版本，可以指定执行异步任务的Executor实现，如果不指定，默认使用ForkJoinPool.commonPool()，如果机器是单核的，
     * 则默认使用ThreadPerTaskExecutor，该类是一个内部类，每次执行execute都会创建一个新线程。测试用例如下
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @RequestMapping("/runAsync")
    public void runAsync() throws ExecutionException, InterruptedException {
        // 创建异步执行任务，无返回值
        CompletableFuture cf = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread() + " start,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if (false) {
                throw new RuntimeException("test");
            } else {
                System.out.println(Thread.currentThread() + " exit,time->" + System.currentTimeMillis());
            }
        });
        System.out.println("main thread start,time->" + System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->" + cf.get());
        System.out.println("main thread exit,time->" + System.currentTimeMillis());
    }


    @RequestMapping("/runAsyncExecutor")
    public void runAsyncExecutor() throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
// 创建异步执行任务:
        CompletableFuture cf = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread() + " start,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if (false) {
                throw new RuntimeException("test");
            } else {
                System.out.println(Thread.currentThread() + " exit,time->" + System.currentTimeMillis());
            }
        }, executorService);
        System.out.println("main thread start,time->" + System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->" + cf.get());
        System.out.println("main thread exit,time->" + System.currentTimeMillis());
    }

    /**二、异步回调*/


    /**
     * 1、thenApply / thenApplyAsync
     * <p>
     * thenApply 表示某个任务执行完成后执行的动作，即回调方法，会将该任务的执行结果即方法返回值作为入参传递到回调方法中，测试用例如下：
     * <p>
     * <p>
     * 其执行结果如下：
     * Thread[ForkJoinPool-1-worker-1,5,main] start job1,time->1693555321402
     * main thread start cf.get(),time->1693555321402
     * Thread[ForkJoinPool-1-worker-1,5,main] exit job1,time->1693555323416
     * Thread[ForkJoinPool-1-worker-1,5,main] start job2,time->1693555323416
     * run result->1.2
     * main thread start cf2.get(),time->1693555323416
     * <p>
     * <p>
     * job1执行结束后，将job1的方法返回值作为入参传递到job2中并立即执行job2。thenApplyAsync与thenApply的区别在于，前者是将job2提交到线程池中异步执行，
     * 实际执行job2的线程可能是另外一个线程，后者是由执行job1的线程立即执行job2，即两个job都是同一个线程执行的。将上述测试用例中thenApply改成thenApplyAsync后，执行结果如下：
     * <p>
     * main thread start cf.get(),time->1693555391513
     * Thread[ForkJoinPool-3-worker-1,5,main] start job1,time->1693555391513
     * Thread[ForkJoinPool-3-worker-1,5,main] exit job1,time->1693555393524
     * run result->1.2
     * main thread start cf2.get(),time->1693555393524
     * Thread[ForkJoinPool.commonPool-worker-1,5,main] start job2,time->1693555393524
     * Thread[ForkJoinPool.commonPool-worker-1,5,main] exit job2,time->1693555395535
     * run result->test:1.2
     * main thread exit,time->1693555395535
     * <p>
     * <p>
     * <p>
     * 从输出可知，执行job1和job2是两个不同的线程。thenApplyAsync有一个重载版本，可以指定执行异步任务的Executor实现，
     * 如果不指定，默认使用ForkJoinPool.commonPool()。 下述的多个方法，每个方法都有两个以Async结尾的方法，一个使用默认的Executor实现，一
     * 个使用指定的Executor实现，不带Async的方法是由触发该任务的线程执行该任务，带Async的方法是由触发该任务的线程将任务提交到线程池，执行任务的线程跟触发任务的线程不一定是同一个。
     */
    @RequestMapping("/thenApply")
    public void thenApply() throws ExecutionException, InterruptedException {
        ForkJoinPool pool = new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread() + " start job1,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread() + " exit job1,time->" + System.currentTimeMillis());
            return 1.2;
        }, pool);
        //cf关联的异步任务的返回值作为方法入参，传入到thenApply的方法中
        //thenApply这里实际创建了一个新的CompletableFuture实例
        CompletableFuture<String> cf2 = cf.thenApply((result) -> {
            System.out.println(Thread.currentThread() + " start job2,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread() + " exit job2,time->" + System.currentTimeMillis());
            return "test:" + result;
        });
        System.out.println("main thread start cf.get(),time->" + System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->" + cf.get());
        System.out.println("main thread start cf2.get(),time->" + System.currentTimeMillis());
        System.out.println("run result->" + cf2.get());
        System.out.println("main thread exit,time->" + System.currentTimeMillis());
    }

    @RequestMapping("/thenApplyAsync")
    public void thenApplyAsync() throws ExecutionException, InterruptedException {
        ForkJoinPool pool = new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread() + " start job1,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread() + " exit job1,time->" + System.currentTimeMillis());
            return 1.2;
        }, pool);
        //cf关联的异步任务的返回值作为方法入参，传入到thenApplyAsync的方法中
        //thenApplyAsync这里实际创建了一个新的CompletableFuture实例
        CompletableFuture<String> cf2 = cf.thenApplyAsync((result) -> {
            System.out.println(Thread.currentThread() + " start job2,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread() + " exit job2,time->" + System.currentTimeMillis());
            return "test:" + result;
        });
        System.out.println("main thread start cf.get(),time->" + System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->" + cf.get());
        System.out.println("main thread start cf2.get(),time->" + System.currentTimeMillis());
        System.out.println("run result->" + cf2.get());
        System.out.println("main thread exit,time->" + System.currentTimeMillis());
    }

    /**2、thenAccept / thenRun*/
    /**
     * thenAccept 同 thenApply 接收上一个任务的返回值作为参数，但是无返回值；thenRun 的方法没有入参，也买有返回值，测试用例如下：
     * <p>
     * 执行结果如下：
     * Thread[ForkJoinPool-1-worker-1,5,main] start job1,time->1693555655009
     * main thread start cf.get(),time->1693555655010
     * Thread[ForkJoinPool-1-worker-1,5,main] exit job1,time->1693555657018
     * Thread[ForkJoinPool-1-worker-1,5,main] start job2,time->1693555657018
     * run result->1.2
     * main thread start cf2.get(),time->1693555657018
     * Thread[ForkJoinPool-1-worker-1,5,main] exit job2,time->1693555659019
     * Thread[ForkJoinPool-1-worker-1,5,main] start job3,time->1693555659019
     * test:1.2
     * Thread[ForkJoinPool-1-worker-1,5,main] exit job3,time->1693555661023
     * Thread[ForkJoinPool-1-worker-1,5,main] start job4,time->1693555661023
     * thenRun do something
     * Thread[ForkJoinPool-1-worker-1,5,main] exit job4,time->1693555663039
     * run result->null
     * main thread exit,time->1693555663039
     */

    @RequestMapping("/thenAccept")
    public void thenAccept() throws ExecutionException, InterruptedException {

        ForkJoinPool pool = new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread() + " start job1,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread() + " exit job1,time->" + System.currentTimeMillis());
            return 1.2;
        }, pool);
        //cf关联的异步任务的返回值作为方法入参，传入到thenApply的方法中
        CompletableFuture cf2 = cf.thenApply((result) -> {
            System.out.println(Thread.currentThread() + " start job2,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread() + " exit job2,time->" + System.currentTimeMillis());
            return "test:" + result;
        }).thenAccept((result) -> { //接收上一个任务的执行结果作为入参，但是没有返回值
            System.out.println(Thread.currentThread() + " start job3,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(result);
            System.out.println(Thread.currentThread() + " exit job3,time->" + System.currentTimeMillis());
        }).thenRun(() -> { //无入参，也没有返回值
            System.out.println(Thread.currentThread() + " start job4,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println("thenRun do something");
            System.out.println(Thread.currentThread() + " exit job4,time->" + System.currentTimeMillis());
        });
        System.out.println("main thread start cf.get(),time->" + System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->" + cf.get());
        System.out.println("main thread start cf2.get(),time->" + System.currentTimeMillis());
        //cf2 等待最后一个thenRun执行完成
        System.out.println("run result->" + cf2.get());
        System.out.println("main thread exit,time->" + System.currentTimeMillis());

    }

    /**3、 exceptionally*/

    /**
     * exceptionally方法指定某个任务执行异常时执行的回调方法，会将抛出异常作为参数传递到回调方法中，如果该任务正常执行则会exceptionally方法返回的
     * CompletionStage的result就是该任务正常执行的结果，测试用例如下：
     * <p>
     * 执行结果如下：
     * Thread[ForkJoinPool-1-worker-1,5,main]job1 start,time->1693556065461
     * main thread start,time->1693556065462
     * Thread[ForkJoinPool-1-worker-1,5,main] start,time->1693556067468
     * error stack trace->
     * Thread[ForkJoinPool-1-worker-1,5,main] exit,time->1693556069480
     * run result->-1.1
     * main thread exit,time->1693556069480
     * java.util.concurrent.CompletionException: java.lang.RuntimeException: test
     * at java.util.concurrent.CompletableFuture.encodeThrowable(CompletableFuture.java:273)
     * at java.util.concurrent.CompletableFuture.completeThrowable(CompletableFuture.java:280)
     * at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1606)
     * at java.util.concurrent.CompletableFuture$AsyncSupply.exec(CompletableFuture.java:1596)
     * at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)
     * at java.util.concurrent.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1067)
     * at java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1703)
     * at java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:172)
     * Caused by: java.lang.RuntimeException: test
     * at com.chenjie.future.controller.CompletableFutureTest.lambda$exceptionally$13(CompletableFutureTest.java:375)
     * at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1604)
     * <p>
     * <p>
     * 抛出异常后，只有cf2执行了，cf3没有执行。将上述示例中的if(true) 改成if(false)，其输出如下
     * Thread[ForkJoinPool-5-worker-1,5,main]job1 start,time->1693556905715
     * main thread start,time->1693556905716
     * Thread[ForkJoinPool-5-worker-1,5,main]job1 exit,time->1693556907719
     * Thread[ForkJoinPool-5-worker-1,5,main]job2 start,time->1693556907719
     * param->1.2
     * Thread[ForkJoinPool-5-worker-1,5,main]job2 exit,time->1693556909728
     * run result->1.2
     * main thread exit,time->1693556909729
     * <p>
     * <p>
     * cf2没有指定，其result就是cf执行的结果，理论上cf2.get应该立即返回的，此处是等待了cf3，即job2执行完成后才返回，具体原因且待下篇源码分析时再做探讨。
     */
    @RequestMapping("/exceptionally")
    public void exceptionally() throws ExecutionException, InterruptedException {
        ForkJoinPool pool = new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread() + "job1 start,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if (false) {
                throw new RuntimeException("test");
            } else {
                System.out.println(Thread.currentThread() + "job1 exit,time->" + System.currentTimeMillis());
                return 1.2;
            }
        }, pool);
        //cf执行异常时，将抛出的异常作为入参传递给回调方法
        CompletableFuture<Double> cf2 = cf.exceptionally((param) -> {
            System.out.println(Thread.currentThread() + " start,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println("error stack trace->");
            param.printStackTrace();
            System.out.println(Thread.currentThread() + " exit,time->" + System.currentTimeMillis());
            return -1.1;
        });
        //cf正常执行时执行的逻辑，如果执行异常则不调用此逻辑
        CompletableFuture cf3 = cf.thenAccept((param) -> {
            System.out.println(Thread.currentThread() + "job2 start,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println("param->" + param);
            System.out.println(Thread.currentThread() + "job2 exit,time->" + System.currentTimeMillis());
        });
        System.out.println("main thread start,time->" + System.currentTimeMillis());
        //等待子任务执行完成,此处无论是job2和job3都可以实现job2退出，主线程才退出，如果是cf，则主线程不会等待job2执行完成自动退出了
        //cf2.get时，没有异常，但是依然有返回值，就是cf的返回值
        System.out.println("run result->" + cf2.get());
        System.out.println("main thread exit,time->" + System.currentTimeMillis());

    }

    /**4、whenComplete*/
    /**
     * whenComplete是当某个任务执行完成后执行的回调方法，会将执行结果或者执行期间抛出的异常传递给回调方法，如果是正常执行则异常为null，
     * 回调方法对应的CompletableFuture的result和该任务一致，如果该任务正常执行，则get方法返回执行结果，如果是执行异常，则get方法抛出异常。测试用例如下：
     * 执行结果如下：
     * Thread[ForkJoinPool.commonPool-worker-1,5,main]job1 start,time->1693557417427
     * main thread start wait,time->1693557417429
     * Thread[ForkJoinPool.commonPool-worker-1,5,main]job1 exit,time->1693557419437
     * Thread[ForkJoinPool.commonPool-worker-1,5,main]job2 start,time->1693557419437
     * run succ,result->1.2
     * Thread[ForkJoinPool.commonPool-worker-1,5,main]job2 exit,time->1693557421450
     * run result->1.2
     * main thread exit,time->1693557421450
     * 将上述示例中的if(false) 改成if(true)，其输出如下：
     * <p>
     * Thread[ForkJoinPool.commonPool-worker-2,5,main]job1 start,time->1693557612092
     * main thread start wait,time->1693557612092
     * Thread[ForkJoinPool.commonPool-worker-2,5,main]job2 start,time->1693557614094
     * error stack trace->
     * Thread[ForkJoinPool.commonPool-worker-2,5,main]job2 exit,time->1693557616102
     * 2023-09-01 16:40:16.104 ERROR 24944 --- [nio-8005-exec-9] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.util.concurrent.ExecutionException: java.lang.RuntimeException: test] with root cause
     * <p>
     * java.lang.RuntimeException: test
     */
    @RequestMapping("/whenComplete")
    public void whenComplete() throws ExecutionException, InterruptedException {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread() + "job1 start,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if (true) {
                throw new RuntimeException("test");
            } else {
                System.out.println(Thread.currentThread() + "job1 exit,time->" + System.currentTimeMillis());
                return 1.2;
            }
        });
        //cf执行完成后会将执行结果和执行过程中抛出的异常传入回调方法，如果是正常执行的则传入的异常为null
        CompletableFuture<Double> cf2 = cf.whenComplete((a, b) -> {
            System.out.println(Thread.currentThread() + "job2 start,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if (b != null) {
                System.out.println("error stack trace->");
                b.printStackTrace();
            } else {
                System.out.println("run succ,result->" + a);
            }
            System.out.println(Thread.currentThread() + "job2 exit,time->" + System.currentTimeMillis());
        });
        //等待子任务执行完成
        System.out.println("main thread start wait,time->" + System.currentTimeMillis());
        //如果cf是正常执行的，cf2.get的结果就是cf执行的结果
        //如果cf是执行异常，则cf2.get会抛出异常
        System.out.println("run result->" + cf2.get());
        System.out.println("main thread exit,time->" + System.currentTimeMillis());
    }


    /**5、handle*/
    /**
     * 跟whenComplete基本一致，区别在于handle的回调方法有返回值，且handle方法返回的CompletableFuture的result
     * 是回调方法的执行结果或者回调方法执行期间抛出的异常，与原始CompletableFuture的result无关了。测试用例如下：
     *
     * 其执行结果如下：
     * Thread[ForkJoinPool.commonPool-worker-3,5,main]job1 start,time->1693557855709
     * main thread start wait,time->1693557855711
     * Thread[ForkJoinPool.commonPool-worker-3,5,main]job2 start,time->1693557857721
     * error stack trace->
     * Thread[ForkJoinPool.commonPool-worker-3,5,main]job2 exit,time->1693557859734
     * run result->run error
     * main thread exit,time->1693557859734
     * java.util.concurrent.CompletionException: java.lang.RuntimeException: test
     *
     * 将上述示例中的if(true) 改成if(false)，其输出如下：
     *
     * Thread[ForkJoinPool.commonPool-worker-4,5,main]job1 start,time->1693557931882
     * main thread start wait,time->1693557931882
     * Thread[ForkJoinPool.commonPool-worker-4,5,main]job1 exit,time->1693557933886
     * Thread[ForkJoinPool.commonPool-worker-4,5,main]job2 start,time->1693557933886
     * run succ,result->1.2
     * Thread[ForkJoinPool.commonPool-worker-4,5,main]job2 exit,time->1693557935894
     * run result->run succ
     * main thread exit,time->1693557935894
     */
    @RequestMapping("/handle")
    public void handle() throws ExecutionException, InterruptedException {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread() + "job1 start,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if (false) {
                throw new RuntimeException("test");
            } else {
                System.out.println(Thread.currentThread() + "job1 exit,time->" + System.currentTimeMillis());
                return 1.2;
            }
        });
        //cf执行完成后会将执行结果和执行过程中抛出的异常传入回调方法，如果是正常执行的则传入的异常为null
        CompletableFuture<String> cf2 = cf.handle((a, b) -> {
            System.out.println(Thread.currentThread() + "job2 start,time->" + System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if (b != null) {
                System.out.println("error stack trace->");
                b.printStackTrace();
            } else {
                System.out.println("run succ,result->" + a);
            }
            System.out.println(Thread.currentThread() + "job2 exit,time->" + System.currentTimeMillis());
            if (b != null) {
                return "run error";
            } else {
                return "run succ";
            }
        });
        //等待子任务执行完成
        System.out.println("main thread start wait,time->" + System.currentTimeMillis());
        //get的结果是cf2的返回值，跟cf没关系了
        System.out.println("run result->" + cf2.get());
        System.out.println("main thread exit,time->" + System.currentTimeMillis());
    }

    /**三、组合处理*/
    /**1、thenCombine / thenAcceptBoth / runAfterBoth
     *
     * 这三个方法都是将两个CompletableFuture组合起来，只有这两个都正常执行完了才会执行某个任务，区别在于，
     * thenCombine会将两个任务的执行结果作为方法入参传递到指定方法中，且该方法有返回值；thenAcceptBoth同样将两个任务的执行结果作为方法入参，
     * 但是无返回值；runAfterBoth没有入参，也没有返回值。注意两个任务中只要有一个执行异常，则将该异常信息作为指定任务的执行结果。测试用例如下
     *
     * Thread[ForkJoinPool.commonPool-worker-6,5,main] start job1,time->1693559115885
     * Thread[ForkJoinPool.commonPool-worker-7,5,main] start job2,time->1693559115886
     * main thread start cf.get(),time->1693559115892
     * Thread[ForkJoinPool.commonPool-worker-7,5,main] exit job2,time->1693559117397
     * Thread[ForkJoinPool.commonPool-worker-6,5,main] exit job1,time->1693559117897
     * Thread[http-nio-8005-exec-6,5,main] start job3,time->1693559117897
     * Thread[ForkJoinPool.commonPool-worker-6,5,main] start job4,time->1693559117897
     * job3 param a->1.2,b->3.2
     * job4 param a->1.2,b->3.2
     * Thread[ForkJoinPool.commonPool-worker-6,5,main] exit job4,time->1693559119400
     * Thread[http-nio-8005-exec-6,5,main] exit job3,time->1693559119899
     * Thread[http-nio-8005-exec-6,5,main] start job5,time->1693559119899
     * cf5 do something
     * Thread[http-nio-8005-exec-6,5,main] exit job5,time->1693559120905
     * cf run result->1.2
     * main thread start cf5.get(),time->1693559120905
     * cf5 run result->null
     * main thread exit,time->1693559120905
     *
     * job1 和 job2几乎同时运行，job2比job1先执行完成，等job1退出后，job3和job4几乎同时开始运行，job4先退出，等job3执行完成，job5开始了，等job5执行完成后，主线程退出。
     *
     * */
    @RequestMapping("/thenCombine")
    public void thenCombine() throws ExecutionException, InterruptedException {
        ForkJoinPool pool=new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<Double> cf2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return 3.2;
        });
        //cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,且有返回值
        CompletableFuture<Double> cf3=cf.thenCombine(cf2,(a,b)->{
            System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
            System.out.println("job3 param a->"+a+",b->"+b);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
            return a+b;
        });

        //cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,无返回值
        CompletableFuture cf4=cf.thenAcceptBoth(cf2,(a,b)->{
            System.out.println(Thread.currentThread()+" start job4,time->"+System.currentTimeMillis());
            System.out.println("job4 param a->"+a+",b->"+b);
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job4,time->"+System.currentTimeMillis());
        });

        //cf4和cf3都执行完成后，执行cf5，无入参，无返回值
        CompletableFuture cf5=cf4.runAfterBoth(cf3,()->{
            System.out.println(Thread.currentThread()+" start job5,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println("cf5 do something");
            System.out.println(Thread.currentThread()+" exit job5,time->"+System.currentTimeMillis());
        });

        System.out.println("main thread start cf.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf run result->"+cf.get());
        System.out.println("main thread start cf5.get(),time->"+System.currentTimeMillis());
        System.out.println("cf5 run result->"+cf5.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());

    }

    /**2、applyToEither / acceptEither / runAfterEither*/

    /**
     * 这三个方法都是将两个CompletableFuture组合起来，只要其中一个执行完了就会执行某个任务，其区别在于applyToEither会将已经执行完成的任务的执行结果作为方法入参，并有返回值；
     * acceptEither同样将已经执行完成的任务的执行结果作为方法入参，
     * 但是没有返回值；runAfterEither没有方法入参，也没有返回值。注意两个任务中只要有一个执行异常，则将该异常信息作为指定任务的执行结果。测试用例如下
     *
     * 运行结果如下
     * Thread[ForkJoinPool.commonPool-worker-4,5,main] start job1,time->1693561224357
     * Thread[ForkJoinPool.commonPool-worker-5,5,main] start job2,time->1693561224357
     * main thread start cf.get(),time->1693561224358
     * Thread[ForkJoinPool.commonPool-worker-5,5,main] exit job2,time->1693561225859
     * Thread[ForkJoinPool.commonPool-worker-5,5,main] start job4,time->1693561225859
     * job4 param result->3.2
     * Thread[ForkJoinPool.commonPool-worker-4,5,main] exit job1,time->1693561226373
     * Thread[ForkJoinPool.commonPool-worker-4,5,main] start job3,time->1693561226373
     * job3 param result->3.2---1.2
     * cf run result->1.2
     * main thread start cf5.get(),time->1693561226373
     * Thread[ForkJoinPool.commonPool-worker-5,5,main] exit job4,time->1693561227360
     * Thread[ForkJoinPool.commonPool-worker-5,5,main] start job5,time->1693561227360
     * cf5 do something
     * Thread[ForkJoinPool.commonPool-worker-5,5,main] exit job5,time->1693561228366
     * cf5 run result->null
     * main thread exit,time->1693561228366
     * Thread[ForkJoinPool.commonPool-worker-4,5,main] exit job3,time->1693561228381
     * 2023-09-01 17:53:21 JRebel: Reloading class 'com.chenjie.future.controller.CompletableFutureTest'.
     *
     *
     * job1 和job2 同时开始运行，job2先执行完成，然后job4开始执行，理论上job3和job4应该同时开始运行，但是此时只有job4开始执行了，
     * job3是等待job1执行完成后才开始执行，job4先于job3执行完成，然后job5开始执行，等job5执行完成后，主线程退出。上述差异且到下篇源码分析时再做探讨。
     * */

    @RequestMapping("/applyToEither")
    public void applyToEither() throws ExecutionException, InterruptedException {
// 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<Double> cf2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return 3.2;
        });
        //cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,且有返回值
        CompletableFuture<String> cf3=cf.applyToEither(cf2,(results)->{
            System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
            try {
                System.out.println("job3 param result->"+cf2.get()+"---"+results);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } catch (ExecutionException e) {
                throw new RuntimeException(e);
            }
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
            String w = "9.9";
            return w;
        });

        //cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,无返回值
        CompletableFuture cf4=cf.acceptEither(cf2,(result)->{
            System.out.println(Thread.currentThread()+" start job4,time->"+System.currentTimeMillis());
            System.out.println("job4 param result->"+result);
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job4,time->"+System.currentTimeMillis());
        });

        //cf4和cf3都执行完成后，执行cf5，无入参，无返回值
        CompletableFuture cf5=cf4.runAfterEither(cf3,()->{
            System.out.println(Thread.currentThread()+" start job5,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println("cf5 do something");
            System.out.println(Thread.currentThread()+" exit job5,time->"+System.currentTimeMillis());
        });

        System.out.println("main thread start cf.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf run result->"+cf.get());
        System.out.println("main thread start cf5.get(),time->"+System.currentTimeMillis());
        System.out.println("cf5 run result->"+cf5.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());

    }

    /**3、thenCompose*/

    /**
     *  thenCompose方法会在某个任务执行完成后，将该任务的执行结果作为方法入参然后执行指定的方法，该方法会返回一个新的CompletableFuture实例，
     *  如果该CompletableFuture实例的result不为null，则返回一个基于该result的新的CompletableFuture实例；
     *  如果该CompletableFuture实例为null，则，然后执行这个新任务，测试用例如下
     *
     *输出结果
     * Thread[ForkJoinPool.commonPool-worker-6,5,main] start job1,time->1693563054179
     * main thread start cf.get(),time->1693563054180
     * Thread[ForkJoinPool.commonPool-worker-6,5,main] exit job1,time->1693563056184
     * cf run result->1.2
     * main thread start cf2.get(),time->1693563056184
     * Thread[ForkJoinPool.commonPool-worker-6,5,main] start job2,time->1693563056184
     * Thread[ForkJoinPool.commonPool-worker-6,5,main] exit job2,time->1693563058186
     * Thread[ForkJoinPool.commonPool-worker-7,5,main] start job3,time->1693563058190
     * Thread[ForkJoinPool.commonPool-worker-7,5,main] exit job3,time->1693563060194
     * cf2 run result->job3 test
     * main thread exit,time->1693563060195
     *
     *
     * job1执行完成后job2开始执行，等job2执行完成后会把job3返回，然后执行job3，等job3执行完成后，主线程退出。
     * */

    @RequestMapping("/thenCompose")
    public void thenCompose() throws ExecutionException, InterruptedException {
// 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<String> cf2= cf.thenCompose((param)->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return CompletableFuture.supplyAsync(()->{
                System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }
                System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
                return "job3 test";
            });
        });
        System.out.println("main thread start cf.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf run result->"+cf.get());
        System.out.println("main thread start cf2.get(),time->"+System.currentTimeMillis());
        System.out.println("cf2 run result->"+cf2.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

    /**4、allOf / anyOf*/

    /**
     *  allOf返回的CompletableFuture是多个任务都执行完成后才会执行，只有有一个任务执行异常，则返回的CompletableFuture执行get方法时会抛出异常，如果都是正常执行，则get返回null。
     *
     *  输出结果
     *  Thread[ForkJoinPool.commonPool-worker-0,5,main] start job1,time->1693563273152
     * Thread[ForkJoinPool.commonPool-worker-1,5,main] start job2,time->1693563273153
     * Thread[ForkJoinPool.commonPool-worker-2,5,main] start job3,time->1693563273154
     * main thread start cf4.get(),time->1693563273156
     * Thread[ForkJoinPool.commonPool-worker-2,5,main] exit job3,time->1693563274464
     * Thread[ForkJoinPool.commonPool-worker-1,5,main] exit job2,time->1693563274667
     * Thread[ForkJoinPool.commonPool-worker-0,5,main] exit job1,time->1693563275155
     * run succ,result->null
     * cf4 run result->null
     * main thread exit,time->1693563275155
     *
     * 主线程等待最后一个job1执行完成后退出。anyOf返回的CompletableFuture是多个任务只要其中一个执行完成就会执行，
     * 其get返回的是已经执行完成的任务的执行结果，如果该任务执行异常，则抛出异常。将上述测试用例中allOf改成anyOf后，其输出如下
     *
     * */
    @RequestMapping("/allOf")
    public void allOf() throws ExecutionException, InterruptedException {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<Double> cf2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return 3.2;
        });
        CompletableFuture<Double> cf3 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1300);
            } catch (InterruptedException e) {
            }
//            throw new RuntimeException("test");
            System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
            return 2.2;
        });
        //allof等待所有任务执行完成才执行cf4，如果有一个任务异常终止，则cf4.get时会抛出异常，都是正常执行，cf4.get返回null
        //anyOf是只有一个任务执行完成，无论是正常执行或者执行异常，都会执行cf4，cf4.get的结果就是已执行完成的任务的执行结果
        CompletableFuture cf4=CompletableFuture.allOf(cf,cf2,cf3).whenComplete((a,b)->{
            if(b!=null){
                System.out.println("error stack trace->");
                b.printStackTrace();
            }else{
                System.out.println("run succ,result->"+a);
            }
        });

        System.out.println("main thread start cf4.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf4 run result->"+cf4.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }


    /**
     * 主线程等待最后一个job1执行完成后退出。anyOf返回的CompletableFuture是多个任务只要其中一个执行完成就会执行，其get返回的是已经执行完成的任务的执行结果，
     * 如果该任务执行异常，则抛出异常。将上述测试用例中allOf改成anyOf后，其输出如下
     *
     *
     * Thread[ForkJoinPool.commonPool-worker-3,5,main] start job1,time->1693563551721
     * Thread[ForkJoinPool.commonPool-worker-4,5,main] start job2,time->1693563551721
     * Thread[ForkJoinPool.commonPool-worker-5,5,main] start job3,time->1693563551721
     * main thread start cf4.get(),time->1693563551722
     * Thread[ForkJoinPool.commonPool-worker-5,5,main] exit job3,time->1693563553032
     * run succ,result->2.2
     * cf4 run result->2.2
     * main thread exit,time->1693563553032
     * Thread[ForkJoinPool.commonPool-worker-4,5,main] exit job2,time->1693563553234
     * Thread[ForkJoinPool.commonPool-worker-3,5,main] exit job1,time->1693563553737
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @RequestMapping("/anyOf")
    public void anyOf() throws ExecutionException, InterruptedException {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<Double> cf2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return 3.2;
        });
        CompletableFuture<Double> cf3 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1300);
            } catch (InterruptedException e) {
            }
//            throw new RuntimeException("test");
            System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
            return 2.2;
        });
        //allof等待所有任务执行完成才执行cf4，如果有一个任务异常终止，则cf4.get时会抛出异常，都是正常执行，cf4.get返回null
        //anyOf是只有一个任务执行完成，无论是正常执行或者执行异常，都会执行cf4，cf4.get的结果就是已执行完成的任务的执行结果
        CompletableFuture cf4=CompletableFuture.anyOf(cf,cf2,cf3).whenComplete((a,b)->{
            if(b!=null){
                System.out.println("error stack trace->");
                b.printStackTrace();
            }else{
                System.out.println("run succ,result->"+a);
            }
        });

        System.out.println("main thread start cf4.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf4 run result->"+cf4.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }


}
